const { getNotices } = require('../../../api/notice');
const { safeShowGlobalLoading, safeHideGlobalLoading } = require('../../../utils/safeGlobalLoading');

Page({
  data: {
    searchQuery: '',
    currentTab: 'all',
    items: [],
    filteredItems: [],
    loading: false,
    availableTypes: [], // 可用的公告类型
    typeCounts: {}, // 各类型的数量统计
    
    // 全局加载状态
    globalLoading: false,
    globalLoadingText: '村务信息加载中...'
  },

  // 显示全局加载
  showGlobalLoading(text = '村务信息加载中...') {
    const app = getApp()
    app.showGlobalLoading({
      loadingText: text
    })
  },

  // 隐藏全局加载
  hideGlobalLoading() {
    const app = getApp()
    app.hideGlobalLoading()
  },

  // 更新全局加载状态
  updateGlobalLoading(data) {
    this.setData({
      globalLoading: data.globalLoading,
      globalLoadingText: data.globalLoadingText || this.data.globalLoadingText
    })
  },

  onLoad() {
    // 显示页面加载效果
    safeShowGlobalLoading(this, '村务信息加载中...')
    this.loadNotices();
  },

  // 加载公告数据（一次性获取所有已发布的公告）
  async loadNotices() {
    if (this.data.loading) return;
    
    this.setData({ loading: true });
    
    try {
      const params = {
        page: 1,
        limit: 100, // 获取足够的数据，确保获取所有已发布的公告
        status: 'published', // 只获取已发布的公告
        sortBy: 'publish_time',
        sortOrder: 'desc'
      };
      
      console.log('正在获取所有已发布公告数据...', params);
      
      const response = await getNotices(params);
      
      if (response.success) {
        const { notices } = response.data;
        
        // 格式化数据
        const formattedNotices = notices.map(notice => ({
          id: notice.id,
          type: notice.type,
          typeText: this.getTypeText(notice.type),
          title: notice.title,
          time: this.formatTime(notice.publishTime),
          dept: notice.dept || '村委会',
          isUrgent: notice.isUrgent,
          readCount: notice.readCount
        }));
        
        // 分析可用的公告类型
        const typeAnalysis = this.analyzeNoticeTypes(formattedNotices);
        
        // 计算总数量
        const totalCount = Object.values(typeAnalysis.counts).reduce((sum, count) => sum + count, 0);
        
        this.setData({
          items: formattedNotices,
          availableTypes: typeAnalysis.types,
          typeCounts: typeAnalysis.counts,
          totalCount: totalCount,
          loading: false
        });
        
        // 筛选数据
        this.filterItems();
        
        // 隐藏全局加载效果
        setTimeout(() => {
          safeHideGlobalLoading(this)
        }, 500);
        
        console.log('公告数据加载成功:', formattedNotices.length, '条');
        console.log('可用类型:', typeAnalysis.types);
        console.log('类型统计:', typeAnalysis.counts);
      } else {
        console.error('获取公告数据失败:', response.message);
        wx.showToast({
          title: response.message || '获取数据失败',
          icon: 'none'
        });
        this.setData({ loading: false });
        // 隐藏全局加载效果
        safeHideGlobalLoading(this)
      }
    } catch (error) {
      console.error('获取公告数据异常:', error);
      wx.showToast({
        title: '网络异常，请重试',
        icon: 'none'
      });
      this.setData({ loading: false });
      // 隐藏全局加载效果
      safeHideGlobalLoading(this)
    }
  },

  // 分析公告类型，生成可用的筛选条件
  analyzeNoticeTypes(notices) {
    const typeCounts = {};
    const typeMap = {
      'notice': '通知公告',
      'finance': '财务公开', 
      'project': '项目建设',
      'policy': '政策法规',
      'activity': '活动信息',
      'urgent': '紧急通知'
    };
    
    // 统计各类型的数量
    notices.forEach(notice => {
      typeCounts[notice.type] = (typeCounts[notice.type] || 0) + 1;
    });
    
    // 生成可用的类型列表（按数量排序）
    const types = Object.keys(typeCounts)
      .filter(type => typeCounts[type] > 0)
      .sort((a, b) => typeCounts[b] - typeCounts[a])
      .map(type => ({
        key: type,
        name: typeMap[type] || type,
        count: typeCounts[type]
      }));
    
    return { types, counts: typeCounts };
  },

  // 获取类型文本
  getTypeText(type) {
    const typeMap = {
      'notice': '通知',
      'finance': '财务',
      'project': '项目',
      'policy': '政策',
      'activity': '活动',
      'urgent': '紧急'
    };
    return typeMap[type] || '公告';
  },

  // 格式化时间
  formatTime(timeStr) {
    if (!timeStr) return '';
    
    const date = new Date(timeStr);
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    return `${month}-${day}`;
  },

  // 切换标签
  onTabChange(e) {
    const tab = e.currentTarget.dataset.tab;
    this.setData({ currentTab: tab });
    this.filterItems();
  },

  // 搜索输入
  onSearchInput(e) {
    this.setData({ searchQuery: e.detail.value });
  },

  // 搜索确认
  onSearchConfirm() {
    this.filterItems();
  },

  // 点击搜索按钮
  onSearch() {
    this.filterItems();
  },

  // 点击列表项
  onTapItem(e) {
    const id = e.currentTarget.dataset.id;
    const item = this.data.items.find(item => item.id === id);
    
    if (item) {
      // 跳转到详情页面
      wx.navigateTo({
        url: `/pages/village/notice-detail/index?id=${item.id}`
      });
    } else {
      wx.showToast({
        title: '数据异常',
        icon: 'none'
      });
    }
  },

  // 筛选数据（前端筛选，支持类型和搜索）
  filterItems() {
    let result = this.data.items;
    const { currentTab, searchQuery } = this.data;
    
    // 按类型筛选
    if (currentTab !== 'all') {
      result = result.filter(item => item.type === currentTab);
    }
    
    // 按搜索关键词筛选
    if (searchQuery && searchQuery.trim()) {
      const query = searchQuery.toLowerCase().trim();
      result = result.filter(item => 
        item.title.toLowerCase().includes(query) || 
        item.dept.toLowerCase().includes(query)
      );
    }
    
    this.setData({ filteredItems: result });
  },

  // 下拉刷新
  onPullDownRefresh() {
    // 显示刷新加载效果
    safeShowGlobalLoading(this, '正在刷新...')
    this.loadNotices().finally(() => {
      wx.stopPullDownRefresh();
    });
  },

})